/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "ui文件对话框.h"
#include "../intern/ui列表.h"

#include "../intern/ui文本编辑.h"
#include "UI/UI.h"
#include "窗口/窗口.h"


#include <file_文件名数据.h>





static std::vector<std::u16string>	g当前要处理文件;
static std::u16string				g显示文件名;

static E_对话框类型				g_文件处理方式 = E_对话框类型::e_读取;
static C_超级列表编辑框*        g当前打开列表框的编辑框 = nullptr;

static uint16 gDraw文件列表_属性ID = 0;
static uint16 g_快捷栏滚动窗口绘制属性 = 0;
static uint16 g_快捷栏内部组件绘制属性 = 0;






static bool f_文件列表浏览打开关闭(C_列表框* listBox, std::filesystem::path 路径, const std::vector<std::u16string>& 后缀, bool 是否包含文件 = true) {
	//C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(self->m_父部件);
	g当前要处理文件.clear();

	S_目录文件包 files;
	if (是否包含文件) {
		f_file_get目录下所有文件名(路径.u16string(), files, 后缀);
	}
	else {
		f_file_get目录下所有目录名(路径.string(), files);
	}
	


	std::vector<S_列表填充数据> data;
	for (auto& s : files.目录) {
		data.push_back({ u"文件夹", S_UI主题::uic_文件夹, {s, u"", u""} });
	}
	if (是否包含文件) {
		for (auto& s : files.文件) {
			data.push_back({ u"文件", S_UI主题::uic_文件, {s, u"", u""} });
		}
	}
	
	listBox->f_填充列表(data);

	g当前要处理文件.push_back(路径.u16string());

	listBox->m_更新绘制属性 = true;
	return true;
}







static E_事件是否传递 on_目录文件快捷栏_鼠标滚轮(C_Widget* self, const S_鼠标& 鼠标) {
	C_目录文件快捷栏* box = dynamic_cast<C_目录文件快捷栏*>(self);

	f_布局_组件纵向滚动(self, f_ui_get滚动框视口(self), C_Widget::g_鼠标.lZ * 40);

	self->m_父部件->m_更新绘制属性 = true;
	return E_事件是否传递::e_事件传递_继续;
}


static bool on_快捷栏打开关闭(C_Widget* self, bool show) {
	assert(dynamic_cast<C_目录文件快捷栏*>(self));
	C_目录文件快捷栏* box = (C_目录文件快捷栏*)(self);

	box->m_盘列表->m_更新绘制属性 = true;

	//std::filesystem::path path;
	std::string path;
	uint8 offset = 0;
	for (uint8 i='a'; i<'z'; ++i) {
		path = i;
		path += ":/";

		//碰到盘不能读就会异常
		std::filesystem::path 路径 = path;
		try {
			//std::filesystem::permissions()
			std::error_code ec;
			bool fuck = std::filesystem::exists(路径, ec);
			if (fuck) {
				S_列表填充数据 item{};
				item.m_ico = u"07";
				item.m_ico_color = S_UI主题::uic_文字颜色;
				item.m_item.push_back(f_str_string_to_u16(path));

				box->m_盘列表->f_addItem(item, offset);
				++offset;
			}
		}
		catch (std::filesystem::filesystem_error const& ex) {
			std::cout
				<< "what():  " << ex.what() << '\n'
				<< "path1(): " << ex.path1() << '\n'
				<< "path2(): " << ex.path2() << '\n'
				<< "code().value():    " << ex.code().value() << '\n'
				<< "code().message():  " << ex.code().message() << '\n'
				<< "code().category(): " << ex.code().category().name() << '\n';
		}

	}
	
	return true;
}





static bool f_目录文件快捷栏列表项选中回调(C_Widget* self, const std::vector<std::u16string>& filenames) {
	C_目录文件快捷栏* box = (C_目录文件快捷栏*)self->m_父部件->m_父部件->m_父部件->m_父部件;

	C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(box->m_父部件);
	filedialog->m_路径 = filenames[0];

	if (filedialog->m_文件处理方式 == E_对话框类型::e_写入 || filedialog->m_文件处理方式 == E_对话框类型::e_读取) {
		f_文件列表浏览打开关闭(filedialog->mui_列表框, filedialog->m_路径, filedialog->m_过滤后缀);
	}
	else {
		f_文件列表浏览打开关闭(filedialog->mui_列表框, filedialog->m_路径, filedialog->m_过滤后缀, false);
	}

	filedialog->mui_右_浏览列表->m_更新绘制属性 = true;
	return true;
}

static bool f_目录文件快捷栏_最近文件列表选中回调(C_Widget* self, const std::vector<std::u16string>& filenames) {
	C_目录文件快捷栏* box = (C_目录文件快捷栏*)self->m_父部件->m_父部件->m_父部件->m_父部件;

	C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(box->m_父部件);
	filedialog->m_路径 = f_file_get路径(filenames[0]);

	if (filedialog->m_文件处理方式 == E_对话框类型::e_写入 || filedialog->m_文件处理方式 == E_对话框类型::e_读取) {
		f_文件列表浏览打开关闭(filedialog->mui_列表框, filedialog->m_路径, filedialog->m_过滤后缀);
	}
	else {
		f_文件列表浏览打开关闭(filedialog->mui_列表框, filedialog->m_路径, filedialog->m_过滤后缀, false);
	}

	filedialog->mui_文件路径编辑框->f_填充文本(filedialog->m_路径.u16string());
	filedialog->mui_文件名编辑框->f_填充文本(f_file_取文件名(filenames[0]));
	filedialog->mui_右_浏览列表->m_更新绘制属性 = true;
	return true;
}

//static bool f_目录文件快捷栏_系统目录列表选中回调(C_Widget* self, const std::vector<std::wstring>& filenames) {
//	C_目录文件快捷栏* box = (C_目录文件快捷栏*)self->m_父部件->m_父部件->m_父部件->m_父部件;
//	C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(box->m_文件列表->m_父部件);
//
//	filedialog->m_路径 = f_file_get路径(filenames[0]);
//
//	f_文件列表浏览打开关闭(filedialog->mui_列表框, filedialog->m_路径, filedialog->m_过滤后缀, true);
//
//	filedialog->mui_文件路径编辑框->f_set文本(filedialog->m_路径);
//	filedialog->mui_文件名编辑框->f_set文本(f_file_取文件名(filenames[0]));
//	filedialog->mui_右_浏览列表->m_更新绘制属性 = true;
//	return true;
//}

static void on_目录文件快捷栏布局(C_Widget* self, C_Widget** w, uint32 num) {
	w[0]->f_setSize(self->m_Size);
	{
		auto 滚动窗口组件 = w[0]->f_get更新组件();

		滚动窗口组件.m_W[0]->f_setX(0);
		滚动窗口组件.m_W[0]->f_setW(w[0]->m_Size.x - (S_UI主题::ui_滚动条厚度 + 10));

		f_布局_纵向滚动条(滚动窗口组件.m_W[1], w[0]->m_Size, 5, w[0]->m_Size.y - self->m_Size.y);
	}
}

static void on_目录文件快捷栏绘制(C_Widget* self, S_2D画布* 画布) {
	assert(dynamic_cast<C_目录文件快捷栏*>(self));
	C_目录文件快捷栏& box = *(C_目录文件快捷栏*)(self);

	box.m_背景 = f_vg_genConvex((*self), *画布, E_填充模式::e_填充面, E_图层混合模式::e_Normal);
	box.m_字符 = f_vg_genString((*self), *画布, E_填充模式::e_填充面, E_图层混合模式::e_Normal, S_UI主题::ui_默认字体);
}

static void on_目录文件快捷栏变换(C_Widget* self) {
	assert(dynamic_cast<C_目录文件快捷栏*>(self));
	C_目录文件快捷栏& box = *(C_目录文件快捷栏*)(self);

	float32 dpi = self->m_UIctx->m_DPI;
	auto e = self->f_get更新组件();

	std::vector<S_2DConvexRect>	区域;
	std::vector<S_GPU内存块*>	形状;
	std::vector<S_2D颜色包>		颜色;
	std::vector<vec2>			位置;

	std::vector<S_Rect2Df>		标签区域;
	std::vector<S_RGBA8UI>		标签颜色;
	std::vector<std::u16string>	标签字符;


	S_2DConvexRect rect{};
	//快捷栏->m_滚动组件绘制.f_alloc(1);
	//快捷栏->m_分类板块绘制.f_alloc(快捷栏->m_单色块使用计数);
	//快捷栏->m_文字绘制.f_alloc(快捷栏->m_单色块使用计数, 100);

	auto 滚动窗口 = e.m_W[0];
	{
		auto soll_e = 滚动窗口->f_get更新组件();
		//快捷栏->m_滚动组件绘制.f_绘制滚动条(0, soll_e.m_W[1]);
		auto soll_view = soll_e.m_W[0];
		{
			auto box = soll_view->f_get更新组件();
			for (uint16 i = 0; i < box.m_Num; ++i) {
				rect.size = box.m_W[i]->m_Size;
				rect.radius = {S_UI主题::ui_面板圆角半径*dpi, S_UI主题::ui_面板圆角半径*dpi};
				rect.AA_type = {1, 0};
				
				vec2 pos = box.m_W[i]->m_Pos + soll_view->m_Pos;
				位置.emplace_back(pos);
				区域.emplace_back(rect);
				颜色.emplace_back(S_2D颜色包(S_UI主题::uic_面板背景, 0,0,0));
				形状.emplace_back(&self->m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形);

				标签字符.emplace_back(box.m_W[i]->m_WName);
				标签颜色.emplace_back(S_UI主题::uic_文字颜色);
				标签区域.emplace_back(S_Rect2Df{pos, {box.m_W[i]->m_Size.x, dpi*30} });

			}
		}

		S_行字符串绘制属性 行字符串绘制属性 = { S_UI主题::ui_文字间隔 * dpi, E_方向::e_横向 };
		f_vg_drawString(*box.m_字符, 标签字符, 标签区域, 标签颜色, E_对齐方式::e_左对齐, 行字符串绘制属性);

		f_vg_drawConvex(*box.m_背景, 区域.size(), 形状.data(), 区域.data());
		f_vg_tranform(*box.m_背景, 位置.size(), 位置.data());
		f_vg_color(*box.m_背景, 颜色.size(), 颜色.data());
	}
}

C_目录文件快捷栏::C_目录文件快捷栏(S_UI渲染环境& ctx) : C_Widget(&ctx) {

	mf_布局 = on_目录文件快捷栏布局;
	mf_绘制 = on_目录文件快捷栏绘制;
	mf_变换 = on_目录文件快捷栏变换;
	mf_打开关闭 = on_快捷栏打开关闭;
	f_widget_添加绘制画布(this);


	C_动态分列栏* 动态分列栏_滚动视口 = new C_动态分列栏(ctx);
	//f_widget_开启视口属性(view);
	//view->mf_鼠标滚轮 = on_目录文件快捷栏_鼠标滚轮;
	C_滚动框* 滚动框 = new C_滚动框(ctx, false, true, 动态分列栏_滚动视口);
	滚动框->mf_鼠标滚轮 = on_目录文件快捷栏_鼠标滚轮;
	//C_滚动条* sh = new C_滚动条(ctx, E_方向::e_纵向);


	//f_添加子组件(view);
	f_添加子组件(滚动框);
	{
		动态分列栏_滚动视口->m_间隔宽度 = 10;
		{
			m_盘列表 = new C_列表框(ctx, 10, E_列表显示模式::e_列表模式_垂直);
			m_盘列表->mf_项选中回调 = f_目录文件快捷栏列表项选中回调;
			m_盘列表->mf_鼠标滚轮 = nullptr;

			C_展开栏* 展开框 = new C_展开栏(ctx, m_盘列表);
			展开框->m_WName = u"盘:";
			展开框->f_setSize({ 300,200 });
			展开框->m_间隔宽度 = 8;
			动态分列栏_滚动视口->f_添加子组件(展开框);


			m_最近文件列表 = new C_列表框(ctx, 10, E_列表显示模式::e_列表模式_垂直);
			m_最近文件列表->mf_鼠标滚轮 = nullptr;
			m_最近文件列表->mf_项选中回调 = f_目录文件快捷栏_最近文件列表选中回调;
			展开框 = new C_展开栏(ctx, m_最近文件列表);
			展开框->m_WName = u"最近文件:";
			展开框->f_setSize({ 300,400 });
			展开框->m_间隔宽度 = 8;
			动态分列栏_滚动视口->f_添加子组件(展开框);


			m_收藏目录列表 = new C_列表框(ctx, 10, E_列表显示模式::e_列表模式_垂直);
			m_收藏目录列表->mf_鼠标滚轮 = nullptr;
			//m_收藏列表->mf_文件选中回调 = f_目录文件快捷栏列表项选中回调;
			展开框 = new C_展开栏(ctx, m_收藏目录列表);
			展开框->m_WName = u"收藏:";
			展开框->f_setSize({ 300,400 });
			展开框->m_间隔宽度 = 8;
			动态分列栏_滚动视口->f_添加子组件(展开框);


			m_系统目录列表 = new C_列表框(ctx, 10, E_列表显示模式::e_列表模式_垂直);
			m_系统目录列表->mf_鼠标滚轮 = nullptr;
			m_系统目录列表->mf_项选中回调 = f_目录文件快捷栏_最近文件列表选中回调;
			展开框 = new C_展开栏(ctx, m_系统目录列表);
			展开框->m_WName = u"系统目录:";
			展开框->f_setSize({ 300,400 });
			展开框->m_间隔宽度 = 8;
			动态分列栏_滚动视口->f_添加子组件(展开框);


		}
	}


	m_单色块使用计数 = 4;

}

C_目录文件快捷栏::~C_目录文件快捷栏() {
}

void C_目录文件快捷栏::f_刷新盘符() {

}

void C_目录文件快捷栏::f_刷新收藏() {

}

void C_目录文件快捷栏::f_刷新历史() {

}







static void f_盘符和浏览记录布局(C_Widget* self, C_Widget** w, uint32 num) {
	
}




static bool f_列表项选中回调(C_Widget* self, const std::vector<std::u16string>& filenames) {
	C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(self->m_父部件->m_父部件->m_父部件);
	C_Widget* 浏览列表 = self->m_父部件->m_父部件;

	if (filedialog) {
		auto path = filedialog->m_路径.u16string();

		g当前要处理文件.clear();

		g显示文件名 = u"";
		for (const auto& name : filenames) {
			std::filesystem::path filepath = path;
			filepath /= name;

			//=========== 进入子目录 ===========
			if (f_file_路径是否为目录(filepath.string())) {
				S_目录文件包 files;

				if (f_file_get目录下所有文件名(filepath.u16string(), files, filedialog->m_过滤后缀)) {
					std::vector<S_列表填充数据> data;
					for (auto& s : files.目录) {
						data.push_back({ u"文件夹", S_UI主题::uic_文件夹, {s, u"", u""} });
					}
					if (filedialog->m_文件处理方式 == E_对话框类型::e_写入 || filedialog->m_文件处理方式 == E_对话框类型::e_读取) {
						for (auto& s : files.文件) {
							data.push_back({ u"文件", S_UI主题::uic_文件, {s, u"", u""} });
						}
					}
					C_列表框* listBox = dynamic_cast<C_列表框*>(self);
					listBox->f_填充列表(data);
					

					g显示文件名 = u"";
					//g当前要处理文件.clear();
					g当前要处理文件.push_back(filepath.u16string());
					filedialog->m_路径 = filepath;
				}

				break;
			}
			else {
				g当前要处理文件.push_back(path);
			}
			filedialog->mui_右_浏览列表->m_更新绘制属性 = true;


			if (g显示文件名.size()) g显示文件名 += u"; ";
			g显示文件名 += name;
		}

		//============================ 文件名编辑框更新 ========================
		if (g显示文件名.size()) {
			//文件名编辑框文本设置
			filedialog->mui_文件名编辑框->f_填充文本(g显示文件名);
		}
		
		filedialog->mui_文件路径编辑框->f_填充文本(filedialog->m_路径.u16string());

	}

	return true;
}





static E_事件是否传递 on_刷新文件夹鼠标点击(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(self->m_父部件->m_父部件->m_父部件);

	if (filedialog->m_文件处理方式 == E_对话框类型::e_写入 || filedialog->m_文件处理方式 == E_对话框类型::e_读取) {
		f_文件列表浏览打开关闭(filedialog->mui_列表框, filedialog->m_路径.string(), filedialog->m_过滤后缀);
	}
	else if (filedialog->m_文件处理方式 == E_对话框类型::e_打开路径) {
		f_文件列表浏览打开关闭(filedialog->mui_列表框, filedialog->m_路径.string(), filedialog->m_过滤后缀, false);
	}
	filedialog->mui_右_浏览列表->m_更新绘制属性 = true;
	return E_事件是否传递::e_事件传递_终止;
}

static E_事件是否传递 on_父级文件夹鼠标点击(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(self->m_父部件->m_父部件->m_父部件);

	//C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(浏览列表->m_父部件);
	//filedialog->路径 = filedialog->m_文件路径;
	filedialog->m_路径 = filedialog->m_路径.parent_path();
	
	if (filedialog->m_文件处理方式 == E_对话框类型::e_写入 || filedialog->m_文件处理方式 == E_对话框类型::e_读取) {
		f_文件列表浏览打开关闭(filedialog->mui_列表框, filedialog->m_路径.string(), filedialog->m_过滤后缀);
	}
	else if (filedialog->m_文件处理方式 == E_对话框类型::e_打开路径) {
		f_文件列表浏览打开关闭(filedialog->mui_列表框, filedialog->m_路径.string(), filedialog->m_过滤后缀, false);
	}
	//f_文件列表加入项(filedialog->mui_列表框, filedialog->m_路径.string(), filedialog->m_文件后缀);

	filedialog->mui_文件路径编辑框->f_填充文本(filedialog->m_路径.u16string());
	filedialog->mui_右_浏览列表->m_更新绘制属性 = true;
	return E_事件是否传递::e_事件传递_终止;
}

static E_事件是否传递 on_文件对话框确定(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(self->m_父部件->m_父部件->m_父部件);

	if (filedialog) {
		if (filedialog->m_文件处理方式 == E_对话框类型::e_写入 || filedialog->m_文件处理方式 == E_对话框类型::e_读取) {
			
			for (auto& e : g当前要处理文件) {
				if (f_file_路径是否为目录(e)) {
					if (e.back() != '/' && e.back() != '\\') e += '/';
					e += (filedialog->mui_文件名编辑框->m_Text);
				}

				auto 扩展名 = f_file_get文件名后缀(e);
				bool 添加扩展名 = true;
				for (auto& 后缀 : filedialog->m_过滤后缀) {
					if (扩展名 == 后缀) {
						添加扩展名 = false;
						break;
					}
				}

				if (添加扩展名 && filedialog->m_过滤后缀.size()) {
					auto 后缀 = filedialog->m_过滤后缀.front();
					if (扩展名 != 后缀) {
						if (e.back() == '.') {
							e.pop_back();
						}
						e += 后缀;
					}
				}
			}
		}
		else if (filedialog->m_文件处理方式 == E_对话框类型::e_打开路径) {
			g当前要处理文件 = { filedialog->m_路径.generic_u16string()};
		}

		
		
		if (filedialog->mui_负责打开的组件) {
			filedialog->mui_负责打开的组件->m_更新绘制属性 = true;
			filedialog->mui_负责打开的组件 = nullptr;
		}
		filedialog->mf_文件处理回调(filedialog, g当前要处理文件, filedialog->m_文件处理方式);

	}


	auto* gm = filedialog->f_get窗口管理();
	f_window_set显示(gm->m_Window, false);
	//if (gm) f_widget_交换顶层组件(gm, 0);

	g当前要处理文件.clear();
	return E_事件是否传递::e_事件传递_终止;
}


bool f_文件对话框打开关闭(C_Widget* self, bool show) {
	auto e = self->mf_get更新组件(self);
	C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(self);
	g_文件处理方式 = filedialog->m_文件处理方式;
	//return false;
	if (e.m_W[0]->mf_打开关闭) e.m_W[0]->mf_打开关闭(e.m_W[0], show);

	if (filedialog->m_文件处理方式 == E_对话框类型::e_读取 || filedialog->m_文件处理方式 == E_对话框类型::e_写入) {
		f_文件列表浏览打开关闭(filedialog->mui_列表框, filedialog->m_路径, filedialog->m_过滤后缀);
	}
	else if (filedialog->m_文件处理方式 == E_对话框类型::e_打开路径) {
		f_文件列表浏览打开关闭(filedialog->mui_列表框, filedialog->m_路径, filedialog->m_过滤后缀, false);
	}

	filedialog->mui_文件名编辑框->f_填充文本(g显示文件名);
	filedialog->mui_文件路径编辑框->f_填充文本(filedialog->m_路径.u16string());
	filedialog->m_更新绘制属性 = true;
	return true;
}



static E_事件是否传递 on_取消按钮鼠标点击(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(self->m_父部件->m_父部件->m_父部件);

	filedialog->m_路径 = filedialog->m_路径.parent_path();
	if (filedialog && filedialog->mf_文件处理回调) {
		filedialog->mf_文件处理回调(filedialog, {}, E_对话框类型::e_关闭);
	}

	if (filedialog->m_父部件->m_Type == E_WidgetType::t_窗口) {
		f_window_set显示((S_Window*)filedialog->m_父部件, false);
	}
	//f_widget_交换顶层组件(filedialog, 0);
	//auto* gm = filedialog->f_get窗口管理();
	//if (gm) f_widget_交换顶层组件(gm, 0);
	return E_事件是否传递::e_事件传递_终止;
}

static E_事件是否传递 on_列表框鼠标滚轮(C_Widget* self, const S_鼠标& 鼠标) {
	//C_列表框* box = dynamic_cast<C_列表框*>(self);
	f_布局_组件纵向滚动(self, f_ui_get滚动框视口(self->f_get子组件(1)), C_Widget::g_鼠标.lZ * 40);
	return E_事件是否传递::e_事件传递_终止;
}




static void on_文件对话框布局(C_Widget* self, C_Widget** w, uint32 num) {
	//C_文件对话框* filedialog = dynamic_cast<C_文件对话框*>(self->m_父部件);
	w[0]->f_setH(24 * self->m_UIctx->m_DPI);
	w[2]->f_setH(24 * self->m_UIctx->m_DPI);

	auto 路径组件 = w[0]->f_get更新组件();
	for (uint32 i = 0; i < 路径组件.m_Num; ++i) {
		路径组件.m_W[i]->f_setSize(_Vec2(24 * self->m_UIctx->m_DPI));
	}

	auto 文件名组件 = w[2]->f_get更新组件();
	for (uint32 i = 0; i < 文件名组件.m_Num; ++i) {
		文件名组件.m_W[i]->f_setH(24 * self->m_UIctx->m_DPI);
	}

	f_VBOX布局(self, w, num);
}

static void on_文件对话框绘制(C_Widget* self, S_2D画布* 画布) {
	S_Surface2D* m_背景 = f_vg_genConvex((*self), *画布, E_填充模式::e_填充面, E_图层混合模式::e_Normal);
	S_Surface2D* m_字符 = f_vg_genString((*self), *画布, E_填充模式::e_填充面, E_图层混合模式::e_Normal, S_UI主题::ui_默认字体);
	S_Surface2D* m_图标 = f_vg_genIco((*self), *画布, E_图层混合模式::e_Normal, E_填充模式::e_填充面, S_UI主题::ui_默认图标);
}

static void on_文件对话框变换(C_Widget* self) {
	//C_文件对话框& box = *dynamic_cast<C_文件对话框*>(self);
	float32 dpi = self->m_UIctx->m_DPI;

	S_Surface2D* m_背景 = f_widget_getSurface2D(self, 0);
	S_Surface2D* m_字符 = f_widget_getSurface2D(self, 1);
	S_Surface2D* m_图标 = f_widget_getSurface2D(self, 2);

	std::vector<S_2DConvexRect>	区域;
	std::vector<S_GPU内存块*>	形状;
	std::vector<S_2D颜色包>		颜色;
	std::vector<vec2>			位置;

	std::vector<S_Rect2Df>		标签区域;
	std::vector<S_RGBA8UI>		标签颜色;
	std::vector<std::u16string>	标签字符;
	std::vector<E_对齐方式>		标签对齐;

	std::vector<std::u16string>	图标名称;
	std::vector<vec2>			图标位置;
	std::vector<vec2>			图标大小;
	std::vector<S_2D颜色包>		图标颜色;
	auto we = self->f_get更新组件();

	S_2DConvexRect rect{};
	//rect.size = self->m_Size;
	//rect.radius = {6,6};
	//rect.AA_type = {1, 0};
	//区域[0] = rect;
	//形状[0] = &(self->m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形);
	//颜色[0] = S_2D颜色包(S_UI主题::uic_深白);
	//位置[0] = {};

	auto 路径组件 = we.m_W[0]->f_get更新组件();
	auto 列表组件 = we.m_W[1]->f_get更新组件();
	auto 文件名组件 = we.m_W[2]->f_get更新组件();


	for (uint32 i = 0; i < 路径组件.m_Num; ++i) {
		rect.size = 路径组件.m_W[i]->m_Size;
		rect.radius = { S_UI主题::ui_面板圆角半径*dpi, S_UI主题::ui_面板圆角半径*dpi };
		区域.emplace_back(rect);
		位置.emplace_back(路径组件.m_W[i]->m_Pos);
		颜色.emplace_back(路径组件.m_W[i]->m_ColorA);
		形状.emplace_back(路径组件.m_W[i]->m_图元形状);

		图标名称.emplace_back(路径组件.m_W[i]->m_ICO);
		图标位置.emplace_back(路径组件.m_W[i]->m_Pos + _Vec2(rect.size.y * 0.5));
		图标大小.emplace_back(_Vec2(rect.size.y*0.75));
		图标颜色.emplace_back(S_2D颜色包(S_UI主题::uic_文字颜色));
	}
	标签区域.push_back({路径组件.m_W[5]->m_Pos + we.m_W[0]->m_Pos, 路径组件.m_W[5]->m_Size});
	标签颜色.push_back(S_UI主题::uic_文字颜色);
	标签字符.push_back(f_ui_get编辑框文本(路径组件.m_W[5]));
	标签对齐.emplace_back(E_对齐方式::e_左对齐);

	标签区域.push_back({路径组件.m_W[6]->m_Pos + we.m_W[0]->m_Pos, 路径组件.m_W[6]->m_Size});
	标签颜色.push_back(S_UI主题::uic_文字颜色);
	标签字符.push_back(f_ui_get编辑框文本(路径组件.m_W[6]));
	标签对齐.emplace_back(E_对齐方式::e_左对齐);


	for (uint32 i = 0; i < 文件名组件.m_Num; ++i) {
		vec2 pos = 文件名组件.m_W[i]->m_Pos + we.m_W[2]->m_Pos;
		rect.size = 文件名组件.m_W[i]->m_Size;
		rect.radius = { S_UI主题::ui_面板圆角半径*dpi, S_UI主题::ui_面板圆角半径*dpi };
		区域.emplace_back(rect);
		位置.emplace_back(pos);
		颜色.emplace_back(文件名组件.m_W[i]->m_ColorA);
		形状.emplace_back(文件名组件.m_W[i]->m_图元形状);

	}

	标签区域.push_back({文件名组件.m_W[0]->m_Pos + we.m_W[2]->m_Pos, 文件名组件.m_W[0]->m_Size});
	标签颜色.push_back(S_UI主题::uic_文字颜色);
	标签字符.push_back(f_ui_get编辑框文本(文件名组件.m_W[0]));
	标签对齐.emplace_back(E_对齐方式::e_左对齐);

	标签区域.push_back({文件名组件.m_W[1]->m_Pos + we.m_W[2]->m_Pos, 文件名组件.m_W[1]->m_Size});
	标签颜色.push_back(S_UI主题::uic_文字颜色);
	标签字符.push_back(文件名组件.m_W[1]->m_WName);
	标签对齐.emplace_back(E_对齐方式::e_据中对齐);

	标签区域.push_back({文件名组件.m_W[2]->m_Pos + we.m_W[2]->m_Pos, 文件名组件.m_W[2]->m_Size});
	标签颜色.push_back(S_UI主题::uic_文字颜色);
	标签字符.push_back(文件名组件.m_W[2]->m_WName);
	标签对齐.emplace_back(E_对齐方式::e_据中对齐);


	//C_列表框& 列表框 = *static_cast<C_列表框*>(列表组件.m_W[0]);
	//rect.offset = { dpi * 列表框.m_行高度, 列表组件.m_W[0]->m_Pos.y};
	//rect.size = we.m_W[1]->m_Size;
	//rect.AA_type = {1, DEF_2DShaderType_Stripe };
	//区域.emplace_back(rect);
	//位置.emplace_back(we.m_W[1]->m_Pos);
	//颜色.emplace_back(列表组件.m_W[0]->m_ColorA);
	//形状.emplace_back(&self->m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形);



	f_vg_drawIco(*m_图标, 图标名称.size(), 图标名称.data());
	f_vg_tranform(*m_图标, 图标位置.size(), 图标位置.data(), 图标大小.data());
	f_vg_color(*m_图标, 图标颜色.size(), 图标颜色.data());

	f_vg_drawConvex(*m_背景, 区域.size(), 形状.data(), 区域.data());
	f_vg_tranform(*m_背景, 位置.size(), 位置.data());
	f_vg_color(*m_背景, 颜色.size(), 颜色.data());

	S_行字符串绘制属性 行字符串绘制属性 = { S_UI主题::ui_文字间隔 * dpi, E_方向::e_横向 };
	f_vg_drawString(*m_字符, 标签字符, 标签区域, 标签颜色, 标签对齐, 行字符串绘制属性);
}


C_文件对话框::C_文件对话框(S_UI渲染环境& ctx) : C_分割框(ctx) {
	m_文件处理方式 = E_对话框类型::e_读取;
	mui_负责打开的组件 = nullptr;
	mf_文件处理回调 = nullptr;
	
	mf_打开关闭 = f_文件对话框打开关闭;
	m_TypeName = DEF_WIDGET_对话框;
	m_区域帧缓存根 = this;

	
	mui_左边_盘符记录 = new C_目录文件快捷栏(ctx);
	mui_左边_盘符记录->m_TypeName = "盘符记录";
	mui_左边_盘符记录->m_文件列表 = mui_右_浏览列表;


	mui_右_浏览列表 = new C_Widget(&ctx);
	mui_右_浏览列表->m_TypeName = "浏览列表";
	f_widget_添加绘制画布(mui_右_浏览列表);

	f_add分割(mui_左边_盘符记录, 0.2f);
	f_add分割(mui_右_浏览列表, 1.0f);
	f_setMinSize({512,512});
	

	mui_右_浏览列表->mf_布局 = on_文件对话框布局;
	mui_右_浏览列表->mf_绘制 = on_文件对话框绘制;
	mui_右_浏览列表->mf_变换 = on_文件对话框变换;
	mui_右_浏览列表->mf_鼠标滚轮 = on_列表框鼠标滚轮;
	mui_右_浏览列表->m_间隔宽度 = 4;
	//return;
	{
		auto* 导航栏 = new C_Widget(&ctx);
		导航栏->m_间隔宽度 = 4;
		导航栏->f_setH(24);
		导航栏->m_是否延展.x = true;
		导航栏->mf_布局 = f_HBOX布局;


		C_按钮* 前一个文件夹 = new C_按钮(&ctx);
		C_按钮* 后一个文件夹 = new C_按钮(&ctx);
		C_按钮* 父级文件夹 = new C_按钮(&ctx);
		C_按钮* 刷新文件夹 = new C_按钮(&ctx);
		C_按钮* 新建文件夹 = new C_按钮(&ctx);
		mui_文件路径编辑框 = new C_行编辑框(ctx);
		C_行编辑框* 文件搜索 = new C_行编辑框(ctx);


		父级文件夹->f_setSize({ 20,20 });
		刷新文件夹->f_setSize({ 20,20 });
		新建文件夹->f_setSize({ 20,20 });

		{
			前一个文件夹->m_绘制标题 = false;
			前一个文件夹->m_绘制图标 = true;
			前一个文件夹->m_ColorA = S_2D颜色包(S_UI主题::uic_按钮背景);
			前一个文件夹->m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形;
			前一个文件夹->m_ICO = u"左";

			后一个文件夹->m_绘制标题 = false;
			后一个文件夹->m_绘制图标 = true;
			后一个文件夹->m_ColorA = S_2D颜色包(S_UI主题::uic_按钮背景);
			后一个文件夹->m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形;
			后一个文件夹->m_ICO = u"右";

			父级文件夹->mf_鼠标点击 = on_父级文件夹鼠标点击;
			父级文件夹->m_绘制标题 = false;
			父级文件夹->m_绘制图标 = true;
			父级文件夹->m_ColorA = S_2D颜色包(S_UI主题::uic_按钮背景);
			父级文件夹->m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形;
			父级文件夹->m_ICO = u"返回";

			刷新文件夹->mf_鼠标点击 = on_刷新文件夹鼠标点击;
			刷新文件夹->m_绘制标题 = false;
			刷新文件夹->m_绘制图标 = true;
			刷新文件夹->m_ColorA = S_2D颜色包(S_UI主题::uic_按钮背景);
			刷新文件夹->m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形;
			刷新文件夹->m_ICO = u"新建文件夹";

			新建文件夹->mf_鼠标点击 = on_刷新文件夹鼠标点击;
			新建文件夹->m_绘制标题 = false;
			新建文件夹->m_绘制图标 = true;
			新建文件夹->m_ColorA = S_2D颜色包(S_UI主题::uic_按钮背景);
			新建文件夹->m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形;
			新建文件夹->m_ICO = u"新建文件夹";

			mui_文件路径编辑框->m_ColorA = S_2D颜色包(S_UI主题::uic_行编辑框背景);
			mui_文件路径编辑框->m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形;

			文件搜索->m_ColorA = S_2D颜色包(S_UI主题::uic_行编辑框背景);
			文件搜索->m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形;
		}


		导航栏->f_添加子组件(前一个文件夹);
		导航栏->f_添加子组件(后一个文件夹);
		导航栏->f_添加子组件(父级文件夹);
		导航栏->f_添加子组件(刷新文件夹);
		导航栏->f_添加子组件(新建文件夹);
		导航栏->f_添加子组件(mui_文件路径编辑框);
		导航栏->f_添加子组件(文件搜索);

		mui_文件路径编辑框->m_是否延展.x = true;
		文件搜索->m_是否延展.x = true;


		mui_右_浏览列表->f_添加子组件(导航栏);
	}

		
	//===================== 中间文件列表 ========================
	{
		auto* listFile = f_ui_创建列表(ctx, E_列表显示模式::e_列表模式_垂直);
		mui_列表框 = (C_列表框*)f_ui_get滚动框视口(listFile);
		mui_列表框->mf_项选中回调 = f_列表项选中回调;
		
		//mui_列表框 = fileView;
		listFile->m_是否延展.x = true;
		listFile->m_是否延展.y = true;
		
		listFile->mf_鼠标滚轮 = nullptr;

		mui_右_浏览列表->f_添加子组件(listFile);
	}


		
	{
		auto* 文件项 = new C_Widget(&ctx);
		文件项->m_间隔宽度 = 4;
		文件项->f_setH(24);
		文件项->m_是否延展.x = true;
		文件项->mf_布局 = f_HBOX布局;


		mui_文件名编辑框 = new C_行编辑框(ctx);
		mui_文件名编辑框->m_是否延展.x = true;
		mui_文件名编辑框->m_ColorA = S_2D颜色包(S_UI主题::uic_行编辑框背景);
		mui_文件名编辑框->m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形;

		mui_打开or确定 = new C_按钮(&ctx, u"确定");
		mui_打开or确定->f_setSize({ 100,20 });
		mui_打开or确定->mf_鼠标点击 = on_文件对话框确定;
		mui_打开or确定->m_ColorA = S_2D颜色包(S_UI主题::uic_按钮背景);
		mui_打开or确定->m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形;

		C_按钮* 取消 = new C_按钮(&ctx, u"取消");
		取消->mf_鼠标点击 = on_取消按钮鼠标点击;
		取消->f_setSize({ 100,20 });
		取消->m_ColorA = S_2D颜色包(S_UI主题::uic_按钮背景);
		取消->m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形;


		文件项->f_添加子组件(mui_文件名编辑框);
		文件项->f_添加子组件(mui_打开or确定);
		文件项->f_添加子组件(取消);

		mui_右_浏览列表->f_添加子组件(文件项);
	}
	
	//f_置子组件绘制根区域为当前组件();
	return;

}

void C_文件对话框::f_set对话框模式(E_对话框类型 类型) {
	m_文件处理方式 = 类型;
	
	if (m_文件处理方式 == E_对话框类型::e_读取) {
		mui_打开or确定->m_WName = u"打开";
	}
	else if (m_文件处理方式 == E_对话框类型::e_写入) {
		mui_打开or确定->m_WName = u"保存";
	}
	else if (m_文件处理方式 == E_对话框类型::e_打开路径) {
		mui_打开or确定->m_WName = u"确定";
	}
	mui_打开or确定->m_更新绘制属性 = true;
}

void f_ui_添加临时文件路径(C_Widget* self, std::vector<std::u16string>& 文件路径) {
	C_文件对话框* 对话框 = dynamic_cast<C_文件对话框*>(self);

	std::vector<S_列表填充数据> data;
	for (auto& e : 文件路径) {
		S_列表填充数据 item;
		item.m_ico = u"";
		item.m_ico_color = { 128,128,128,255 };
		item.m_item = { e };
		item.m_Data = nullptr;
		item.m_ID_X = 0;
		item.m_ID_Y = 0;
		item.m_激活 = false;
		data.push_back(item);
	}
	对话框->mui_左边_盘符记录->m_最近文件列表->f_填充列表(data);
}

void f_ui_对话框填充系统目录(C_Widget* self) {
	C_文件对话框* 对话框 = dynamic_cast<C_文件对话框*>(self);

	const char* envPath = std::getenv("HOME");
	if (!envPath) {
		envPath = std::getenv("USERPROFILE");
		if (!envPath) {
			return;
		}
	}
	std::string 桌面路径 = std::string(envPath) + "/Desktop";


	std::vector<std::u16string> 文件路径;
	文件路径.push_back(f_str_string_to_u16(桌面路径));

	std::vector<S_列表填充数据> data;
	for (auto& e : 文件路径) {
		S_列表填充数据 item;
		item.m_ico = u"";
		item.m_ico_color = { 128,128,128,255 };
		item.m_item = { e };
		item.m_Data = nullptr;
		item.m_ID_X = 0;
		item.m_ID_Y = 0;

		data.push_back(item);
	}
	对话框->mui_左边_盘符记录->m_系统目录列表->f_填充列表(data);
}







static C_路径编辑器* g_当前路径编辑组件 = nullptr;

static void on_路径编辑器布局(C_Widget* self, C_Widget** w, uint32 num) {
	
	float32 按钮宽度 = self->m_Size.y * 1.2;
	w[0]->f_setW(self->m_Size.x - 按钮宽度);
	w[0]->f_setH(self->m_Size.y);

	w[1]->f_setPos({ self->m_Size.x - 按钮宽度, 0.0 });
	w[1]->f_setSize({ 按钮宽度, self->m_Size.y });

	if (self->mf_当前部件属性修改) {
		self->mf_当前部件属性修改(w[0], E_UI绘制调整部分::e_位置);
		self->mf_当前部件属性修改(w[1], E_UI绘制调整部分::e_位置);
	}
}

static void on_路径编辑器按钮单击(struct S_Props& prop) {
	//C_按钮* but = dynamic_cast<C_按钮*>(prop.m_UI->m_部件);
	C_按钮* but = dynamic_cast<C_按钮*>(prop.m_UI->m_部件);

	C_路径编辑器* box = (C_路径编辑器*)(but->m_父部件);
	box->m_对话框是否打开 = false;
	box->m_路径->m_值元素个数 = 0;
	if (box->m_路径->m_UI->m_Update) box->m_路径->m_UI->m_Update(*(box->m_路径));

	C_文件对话框* 对话框 = static_cast<C_文件对话框*>(box->mui_对话框->f_get子组件(0));
	对话框->f_set对话框模式(box->m_对话框类型);
	对话框->mf_文件处理回调 = box->mf_对话框回调;
	//box->m_路径->m_值元素个数 = 1;
	//if (box->mui_对话框->m_文件路径.empty()) {
	//	box->mui_对话框->m_文件路径 = L"c:/";
	//}
	if (对话框->m_路径.empty()) {
		对话框->m_路径 = f_prop_Path(*(box->m_路径));
	}


	g_当前路径编辑组件 = box;
	对话框->mui_负责打开的组件 = box;
	//f_widget_交换顶层组件(but, box->mui_对话框->m_实例ID);
}
static bool f_路径编辑器按钮单击(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_按钮* but = dynamic_cast<C_按钮*>(self);
	if (but->m_自定义属性.m_UI->m_Update) {
		//but->m_Op->m_Func(but->m_Op->m_Obj);
	}

	C_路径编辑器* box = (C_路径编辑器*)(self->m_父部件);
	box->m_对话框是否打开 = false;
	if (box->m_路径->m_UI->m_Update) box->m_路径->m_UI->m_Update(*(box->m_路径));

	C_文件对话框* 对话框 = static_cast<C_文件对话框*>(box->mui_对话框->f_get子组件(0));
	对话框->f_set对话框模式(box->m_对话框类型);
	对话框->mf_文件处理回调 = box->mf_对话框回调;
	//if (box->mui_对话框->m_文件路径.empty()) {
	//	box->mui_对话框->m_文件路径 = L"c:/";
	//}
	if (对话框->m_路径.empty()) {
		对话框->m_路径 = f_prop_Path(*(box->m_路径));
	}


	g_当前路径编辑组件 = box;
	对话框->mui_负责打开的组件 = box;
	//f_widget_交换顶层组件(box->mui_对话框, box->mui_对话框->m_实例ID);
	
	return true;
}

static bool on_文件处理回调(C_Widget* self, const std::vector<std::u16string>& name, E_对话框类型 方式)  {
	C_文件对话框* dialg = (C_文件对话框*)self;

	g_当前路径编辑组件->m_对话框是否打开 = true;
	if (g_当前路径编辑组件->m_路径 && name.size()) {
		f_prop_Path(*(g_当前路径编辑组件->m_路径)) = name[0];
		self->m_更新绘制属性 = true;

		((C_行编辑框*)g_当前路径编辑组件->m_子组件[0])->f_填充文本(f_prop_Path(*(g_当前路径编辑组件->m_路径)).u16string());

		g_当前路径编辑组件->m_路径->m_值元素个数 = name.size();
		g_当前路径编辑组件->m_路径->m_UI->m_Update(*g_当前路径编辑组件->m_路径);
	}
	g_当前路径编辑组件 = nullptr;
	return true;
}
static void on_路径编辑框输入完成(C_Widget* self) {
	C_行编辑框* box = (C_行编辑框*)(self);
	C_路径编辑器* pathBox = (C_路径编辑器*)(box->m_父部件);

	if (pathBox->m_路径) {
		if (f_prop_Path(*(pathBox->m_路径)) != box->m_Text) {
			//if (pathBox->m_对话框类型 == E_对话框类型::e_打开路径) {
			//	if (box->m_Text.back() != L'/' || box->m_Text.back() != L'\\') {
			//		box->m_Text += L"/";
			//	}
			//}

			pathBox->m_路径->m_UI->m_Update(*pathBox->m_路径);
		}

		f_prop_Path(*(pathBox->m_路径)) = box->m_Text;
	}
}

C_路径编辑器::C_路径编辑器(S_UI渲染环境& ctx, C_Widget* 对话框) : C_Widget(&ctx) {
	m_路径 = nullptr;
	mui_对话框 = 对话框;
	mf_布局 = on_路径编辑器布局;
	mf_对话框回调 = on_文件处理回调;
	m_对话框类型 = E_对话框类型::e_读取;

	m_对话框打开按钮 = f_alloc_OpsProp(on_路径编辑器按钮单击, u"打开");
	m_对话框打开按钮.m_私有 = true;
	auto but = f_ui_创建按钮(&ctx);
	
	but->f_bind属性(m_对话框打开按钮);
	m_对话框打开按钮.m_UI->m_部件 = but;
	
	but->m_颜色A = S_UI主题::uic_按钮;
	but->m_颜色B = S_UI主题::uic_按钮背景;
	but->m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面右圆角矩形;
	but->m_ICO = u"folder_open";


	auto edit = new C_行编辑框(ctx);
	edit->m_颜色A = S_UI主题::uic_行编辑框背景;
	edit->m_颜色B = S_UI主题::uic_行编辑框边框;
	edit->m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面左圆角矩形;
	edit->m_文本对齐偏移.x = S_UI主题::ui_面板圆角半径*1.5;
	edit->m_文本对齐偏移.y = -1.0;
	edit->mf_文本完成 = on_路径编辑框输入完成;

	f_添加子组件(edit);
	f_添加子组件(but);
}

C_路径编辑器::~C_路径编辑器() {
}


void f_ui_set路径编辑框对话框类型(C_Widget* self, E_对话框类型 对话框类型) {
	((C_路径编辑器*)(self))->m_对话框类型 = 对话框类型;
}

void f_ui_set路径编辑框对话框后缀(C_Widget* self, std::string 后缀) {
	C_路径编辑器* 路径框 = dynamic_cast<C_路径编辑器*>(self);
	if (路径框) {
		//路径框->mui_对话框->m_文件后缀 = 后缀;
		//路径框->mui_对话框->m_过滤后缀 = { f_StringToString(后缀) };
	}
	//((C_路径编辑器*)(self))->mui_对话框->m_文件后缀 = 后缀;
}

void f_ui_set路径编辑框对话框过滤后缀(C_Widget* self, const std::vector<std::u16string>& 后缀) {
	C_路径编辑器* 路径框 = dynamic_cast<C_路径编辑器*>(self);
	if (路径框) {
		C_文件对话框* 对话框 = static_cast<C_文件对话框*>(路径框->mui_对话框->f_get子组件(0));
		对话框->m_过滤后缀 = 后缀;
	}
}

C_Widget* f_ui_创建路径编辑框(S_UI渲染环境& ctx, C_Widget* 对话框, fp_Widget绘制调整回调 绘制调整回调) {
	if (对话框 && 对话框->m_Type == E_WidgetType::t_文件对话框) {
		C_路径编辑器* box = new C_路径编辑器(ctx, 对话框);
		box->m_子组件[0]->mf_当前部件属性修改 = 绘制调整回调;
		box->m_子组件[1]->mf_当前部件属性修改 = 绘制调整回调;

		return box;
	}
	return nullptr;
}






static bool on_下拉列表按钮鼠标进入(C_Widget* self, const S_鼠标& 鼠标) {
	//self->m_颜色A = self->m_颜色A + S_RGBA8UI{ 50, 50, 50, 127 };
	//self->m_父部件->m_绘制属性更新 = true;
	return false;
}

static bool on_下拉列表按钮鼠标退出(C_Widget* self, const S_鼠标& 鼠标) {
	//self->m_颜色A = self->m_颜色B;
	//self->m_父部件->m_绘制属性更新 = true;
	return false;
}


static void on_超级列表编辑框布局(C_Widget* self, C_Widget** w, uint32 num) {
	C_超级列表编辑框* box = static_cast<C_超级列表编辑框*>(self);
	float32 size = self->m_Size.y;

	auto e = self->f_get更新组件();
	e.m_W[0]->f_setSize({ size, size });
	e.m_W[1]->f_setSize({ size, size });
	e.m_W[2]->f_setSize({ size, size });
	e.m_W[3]->f_setSize({ size, size });

	e.m_W[0]->m_是否延展 = { false, false };
	e.m_W[1]->m_是否延展 = { true, true };
	e.m_W[2]->m_是否延展 = { false, false };
	e.m_W[3]->m_是否延展 = { false, false };
	f_HBOX布局(self, e.m_W, e.m_Num);
}

static E_事件是否传递 f_选择按钮单击(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_按钮* but = static_cast<C_按钮*>(self);

	C_超级列表编辑框* 超级列表编辑框 = static_cast<C_超级列表编辑框*>(but->m_父部件);
	g当前打开列表框的编辑框 = 超级列表编辑框;


	f_ui_绑定超级列表编辑框属性(超级列表编辑框, 超级列表编辑框->m_自定义属性);

	vec2 pos = { self->m_裁剪大小.x, self->m_裁剪大小.w };
	auto 区域 = f_widget_get当前窗口矩形();
	
	超级列表编辑框->m_列表视口->f_setSize({ 200, 200 });
	
	pos = f_widget_弹出窗口坐标矫正(超级列表编辑框->m_列表视口, pos);
	if (pos.y + 超级列表编辑框->m_列表视口->m_Size.y >= 区域.w) {
		pos.y = self->m_裁剪大小.y - 超级列表编辑框->m_列表视口->m_Size.y;
	}

	超级列表编辑框->m_列表视口->f_setPos(pos);
	


	f_widget_顶层窗口_pop(f_ui_当前窗口管理(), 0);
	f_widget_top_push(f_ui_当前窗口管理(), 超级列表编辑框->m_列表视口);
	f_widget_线程定时关闭弹出组件(1000);

	f_widget_单个部件裁剪(
		超级列表编辑框->m_列表视口, 
		{ 0, 0, pos.x + 超级列表编辑框->m_列表视口->m_Size.x + 3, pos.y + 超级列表编辑框->m_列表视口->m_Size.y + 3 }, {} );

	return E_事件是否传递::e_事件传递_终止;
}

static E_事件是否传递 f_添加项按钮单击(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_按钮* but = static_cast<C_按钮*>(self);
	C_超级列表编辑框* 超级列表编辑框 = static_cast<C_超级列表编辑框*>(but->m_父部件);

	超级列表编辑框->m_列表视口;

	return E_事件是否传递::e_事件传递_终止;
}

static E_事件是否传递 f_删除项按钮单击(C_Widget* self, const E_鼠标按钮& 按钮) {
	C_按钮* but = static_cast<C_按钮*>(self);
	C_超级列表编辑框* 超级列表编辑框 = static_cast<C_超级列表编辑框*>(but->m_父部件);

	超级列表编辑框->m_列表视口;

	return E_事件是否传递::e_事件传递_终止;
}

static bool on_列表项选中回调(C_Widget* self, const S_列表填充数据& item) {
	if (g当前打开列表框的编辑框) {
		S_映射引用2D& 映射的数据 = f_prop_映射引用2D(g当前打开列表框的编辑框->m_自定义属性);
		if (映射的数据.mf_元素选择) {
			
			auto 引用项 = f_prop_get2D映射引用项(g当前打开列表框的编辑框->m_自定义属性, { uint32(item.m_ID_X), uint32(item.m_ID_Y) });
			((C_行编辑框*)g当前打开列表框的编辑框->m_文本编辑框)->f_填充文本(引用项.m_Str);

			映射的数据.m_当前项 = { uint32(item.m_ID_X), uint32(item.m_ID_Y) };
			映射的数据.mf_元素选择(g当前打开列表框的编辑框, item);
		}
		return true;
	}
	return false;
}

static void on_列表项外部改变更新回调(S_Props& prop) {
	//C_超级列表编辑框* 超级列表编辑框 = static_cast<C_超级列表编辑框*>(prop.m_UI->m_部件);
	C_超级列表编辑框* 超级列表编辑框 = static_cast<C_超级列表编辑框*>(prop.m_UI->m_部件);

	auto& p = f_prop_映射引用2D(prop);
	auto 引用项 = f_prop_get2D映射引用项(prop, p.m_当前项);
	((C_行编辑框*)超级列表编辑框->m_文本编辑框)->f_填充文本(引用项.m_Str);
}

C_超级列表编辑框::C_超级列表编辑框(S_UI渲染环境& ctx) : C_Widget(&ctx) {
	mf_布局 = on_超级列表编辑框布局;

	m_选择按钮 = new C_按钮(&ctx);
	m_文本编辑框 = new C_行编辑框(ctx);
	m_拷贝项按钮 = new C_按钮(&ctx);
	m_添加项按钮 = new C_按钮(&ctx);
	m_移除项按钮 = new C_按钮(&ctx);


	m_列表视口 = new C_超级弹出菜单(ctx);
	
	m_选择按钮->m_ICO = u"import";
	m_拷贝项按钮->m_ICO = u"clipboard_copy";
	m_添加项按钮->m_ICO = u"新建文件";
	m_移除项按钮->m_ICO = u"删除";

	m_选择按钮->m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面左圆角矩形;
	m_文本编辑框->m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面矩形;
	m_拷贝项按钮->m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面矩形;
	m_添加项按钮->m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面矩形;
	m_移除项按钮->m_图元形状 = &m_UIctx->m_Ctx.m_几何图形->m_平面右圆角矩形;

	f_添加子组件(m_选择按钮);
	f_添加子组件(m_文本编辑框);
	f_添加子组件(m_拷贝项按钮);
	f_添加子组件(m_添加项按钮);
	f_添加子组件(m_移除项按钮);

	m_选择按钮->mf_鼠标点击 = f_选择按钮单击;
	m_添加项按钮->mf_鼠标点击 = f_添加项按钮单击;
	m_移除项按钮->mf_鼠标点击 = f_删除项按钮单击;


	f_ui_弹出面板项回调绑定(m_列表视口->m_弹出面板, on_列表项选中回调);
}

C_超级列表编辑框::~C_超级列表编辑框() {

}

void C_超级列表编辑框::f_bind属性(S_Props& prop) {
	C_Widget::f_bind属性(prop);

	m_列表视口->m_弹出面板->m_Value = prop;

	m_自定义属性.m_UI->m_Set = on_列表项外部改变更新回调;

	auto itemData = f_prop_映射引用2D(m_自定义属性);

	uint32 x_id = 0;
	for (auto& x : itemData.m_PtrItem) {
		uint32 y_id = 0;
		for (auto& y : *x) {
			S_列表填充数据 item{};

			item.m_item.push_back(y.m_Str);
			item.m_Data = y.m_Ptr;
			item.m_ico = y.m_Ico;
			item.m_ID_X = x_id;
			item.m_ID_Y = y_id;

			f_ui_添加弹出面板菜单项(m_列表视口->m_弹出面板, item, { x_id, y_id });
			++y_id;
		}

		++x_id;
	}

	auto item = f_prop_get2D映射引用项(m_自定义属性, itemData.m_当前项);
	((C_行编辑框*)m_文本编辑框)->f_填充文本(item.m_Str);
}



C_Widget* f_ui_创建超级列表编辑框(S_UI渲染环境& ctx, bool 项名称编辑, bool 列表项编辑) {
	C_超级列表编辑框* box = new C_超级列表编辑框(ctx);

	return box;
}

void f_ui_绑定超级列表编辑框属性(C_Widget* self, S_Props& prop) {
	//C_超级列表编辑框* box = dynamic_cast<C_超级列表编辑框*>(self);
	//box->m_列表属性 = prop;
	//box->m_列表视口->m_弹出面板->m_Value = prop;
	//
	//prop.m_UI->m_Set = on_列表项外部改变更新回调;
	//
	//auto itemData = f_prop_映射引用2D(prop);
	//
	//uint32 x_id = 0;
	//for (auto& x : itemData.m_PtrItem) {
	//	uint32 y_id = 0;
	//	for (auto& y : *x) {
	//		S_列表填充数据 item{};
	//
	//		item.m_item.push_back(y.m_Str);
	//		item.m_Data = y.m_Ptr;
	//		item.m_ico = y.m_Ico;
	//		item.m_ID_X = x_id;
	//		item.m_ID_Y = y_id;
	//		
	//		f_ui_添加弹出面板菜单项(box->m_列表视口->m_弹出面板, item, { x_id, y_id });
	//		++y_id;
	//	}
	//
	//	++x_id;
	//}
	//
	////f_ui_弹出面板项回调绑定(box->m_列表视口->m_弹出面板, itemData.mf_元素选择);
	//
	//auto item = f_prop_get2D映射引用项(prop, itemData.m_当前项);
	//((C_行编辑框*)box->m_文本编辑框)->f_set文本(item.m_Str);
}

void f_ui_绑定超级列表编辑框添加项回调消息(S_UI渲染环境& ctx, bool 项名称编辑, bool 列表项编辑) {

}






